class WebSocketService {
    constructor() {
        // WebSocket 实例
        this.socket = null;
        // 连接状态（0:未连接, 1:连接中, 2:已连接）
        this.status = 0;
        // 连接地址（根据实际后端地址修改）
        this.url = '';
        // 重连计时器
        this.reconnectTimer = null;
        // 重连次数限制
        this.maxReconnectCount = 10;
        this.currentReconnectCount = 0;
    }

    /**
     * 初始化连接
     * @param {String} url - WebSocket 连接地址（如 ws://172.16.100.188:8080/ws/group-chat?groupId=xxx&userId=xxx）
     * @param {Function} onMessage - 接收消息的回调函数
     * @param {Function} onOpen - 连接成功的回调函数
     * @param {Function} onClose - 连接关闭的回调函数
     * @param {Function} onError - 连接错误的回调函数
     */
    connect({ url, onMessage, onOpen, onClose, onError }) {
        if (this.status === 1 || this.status === 2) {
            console.log('WebSocket 已连接或正在连接中');
            return;
        }

        this.url = url;
        this.status = 1; // 标记为连接中
        this.currentReconnectCount = 0; // 重置重连次数

        // 建立连接
        this.socket = uni.connectSocket({
            url: this.url,
            header: {
                'content-type': 'application/json'
            },
            method: 'GET',
            // #ifdef MP-WEIXIN
            // 微信小程序需指定协议版本（默认13，部分服务器可能需要调整）
            // protocols: ['protocol1'],
            // #endif
            success: () => {
                console.log('WebSocket 连接请求发送成功');
            },
            fail: (err) => {
                console.error('WebSocket 连接请求失败', err);
                this.status = 0;
                onError && onError(err);
            }
        });

        // 监听连接成功
        this.socket.onOpen((res) => {
            console.log('WebSocket 连接成功');
            this.status = 2;
            this.currentReconnectCount = 0; // 连接成功重置重连次数
            onOpen && onOpen(res);
        });

        // 监听接收消息
        this.socket.onMessage((res) => {
            console.log('收到消息:', res.data);
            // 消息通常是 JSON 字符串，需解析
            try {
                const data = JSON.parse(res.data);
                onMessage && onMessage(data);
            } catch (e) {
                // 非 JSON 格式消息直接返回
                onMessage && onMessage(res.data);
            }
        });

        // 监听连接关闭
        this.socket.onClose((res) => {
            console.log('WebSocket 连接关闭', res);
            this.status = 0;
            onClose && onClose(res);

            // 自动重连（非手动关闭时）
            if (this.currentReconnectCount < this.maxReconnectCount) {
                this.reconnect();
            }
        });

        // 监听连接错误
        this.socket.onError((err) => {
            console.error('WebSocket 连接错误', err);
            this.status = 0;
            onError && onError(err);

            // 错误时触发重连
            if (this.currentReconnectCount < this.maxReconnectCount) {
                this.reconnect();
            }
        });
    }

    /**
     * 发送消息
     * @param {Object|String} data - 要发送的消息（对象会自动转为 JSON 字符串）
     */
    send(data) {
        if (this.status !== 2) {
            console.error('WebSocket 未连接，无法发送消息');
            return false;
        }

        const sendData = typeof data === 'object' ? JSON.stringify(data) : data;
        this.socket.send({
            data: sendData,
            success: () => {
                console.log('消息发送成功:', sendData);
                return true;
            },
            fail: (err) => {
                console.error('消息发送失败:', err);
                return false;
            }
        });
    }

    /**
     * 关闭连接（手动关闭，不触发重连）
     */
    close() {
        if (this.socket) {
            this.socket.close({
                code: 1000, // 正常关闭代码
                reason: '手动关闭连接'
            });
            this.socket = null;
            this.status = 0;
            // 清除重连计时器
            if (this.reconnectTimer) {
                clearTimeout(this.reconnectTimer);
                this.reconnectTimer = null;
            }
        }
    }

    /**
     * 重连机制（指数退避，避免频繁重连）
     */
    reconnect() {
        this.currentReconnectCount++;
        const delay = Math.min(1000 * this.currentReconnectCount, 10000); // 最大延迟10秒
        console.log(`准备第 ${this.currentReconnectCount} 次重连，延迟 ${delay}ms`);

        this.reconnectTimer = setTimeout(() => {
            console.log('开始重连...');
            this.connect({
                url: this.url,
                onMessage: this.onMessage,
                onOpen: this.onOpen,
                onClose: this.onClose,
                onError: this.onError
            });
        }, delay);
    }

    // 保存回调函数（用于重连时复用）
    setCallbacks({ onMessage, onOpen, onClose, onError }) {
        this.onMessage = onMessage;
        this.onOpen = onOpen;
        this.onClose = onClose;
        this.onError = onError;
    }
}

// 导出单例实例（全局唯一连接）
export default new WebSocketService();